import { type } from "os"

let myname:String = "aaa"
console.log(myname+"cc")
function sum(a:number,b:number):number{
    return a+b
}
let num:number=sum(12,12)
console.log(num)

// 布尔 
function isOdd(num:number):boolean{
    return num%2 ===0
}
// 数组
let arr:number[] = [3,46,6];
let nums:Array<number> = [2,34,56]
// 对象

// null 与undefined 是其他类型的子集
// 可以赋值给其他类型
// 若控制可以加 strickenNullChecks：true
// 此时undefined与null只能赋值给自身

// 联合类型 将多种类型任选其一
let firstName:string|undefined;
if(typeof firstName==="string"){
    firstName.indexOf("li")
}


// void类型 返回空函数
function Pringname():void{
    console.log("aaa")
}

// never 约束函数的返回值，表示函数永远不会结束

// 字面量类型 使用一个值约束
let gender:"男"|"女"
gender = "女";
 let Arr01:[] // Arr01 只能为[]
//  Arr01= [123] 
// 元祖类型 长度固定 每一项确定
let tu:[string,number]
tu=["12",21]

// 类型别名
// 对一致的类型定义别名
type gender = "男"|"女"
type User={
    name:string,
    age:number,
    gender:gender
}

let perSon:User
perSon = {
    name:"ad",
    age:12,
    gender:"男"
}
function getUsers(g:gender):User[]{
    return []
}



// 函数的相关约束
// 函数重载 对函数的多次调用多种情况的声明
function combine(a:number,b:number):number;
function combine(a:string,b:string):string;
function combine(a:number|string,b:number|string):number|string{
    if(typeof a==="number"&& typeof b==="number"){
        return a*b
    }
    if(typeof a==="string"&& typeof b==="string"){
        return a+b
    }
    throw new Error("参数类型错误")
}
const resule = combine("b","a");


// 情况2
// 函数的可选参数及默认参数 默认参数相当于可选参数
function getSum(a:number,b:number=5,c?:number){
    if(c){
        return a+b+c
    }
    else{
        return a+b
    }
}

const sumA=getSum(6)
console.log(sumA)